מבני נתונים תכנות מונחה עצמים מבני נתונים. מחלקות אבסטרקטיות חבילות packages סיכום הרשאות גישה wrappers ADT מערך דינמי מחסנית

Transcription

1 מבני נתונים 1 תכנות מונחה עצמים מחלקות אבסטרקטיות חבילות packages סיכום הרשאות גישה wrappers מבני נתונים ADT מערך דינמי מחסנית 2 1

2 מבני נתונים תור - Queue Iterators רשימות מקושרות "רגילות" 3 מבנה נתונים הוא דרך לאחסון נתונים במחשב מבנה נתונים מופשט Type( )ADT Abstract Data הוא תיאור מופשט של הפעולות של מבנה הנתונים. כלי התכנות בו נשתמש לתיאור מבנה נתונים מופשט הוא הממשק. מבנה נתונים קונקרטי הוא המימוש בפועל של מבנה הנתונים המופשט. 4 2

3 public interface Array{ public Object get(int i); public void set(int i, Object data); public int size(); סוגי מבני נתונים שראינו שבוע שעבר: public interface Set{ public void add(object data); public void remove(object data); public boolean contains(object data); public int size(); Array מערך בעל קיבולת משתנה Set קבוצה 5 public interface Stack { public void push(object o); public Object pop(); public boolean isempty(); Stack מחסנית 6 3

4 public class StackAsArray implements Stack { private Array arr; private int numofelements; public StackAsArray(Array arr){ this.arr = arr; numofelements = 0; public StackAsArray(){ this(new DynamicArray()); 7 public boolean isempty() {return numofelements == 0; public void push(object o) { arr.set(numofelements, o); numofelements = numofelements+1; public Object pop() { if (isempty()) throw new RuntimeException("Cannot pop from an empty stack."); numofelements = numofelements-1; Object res = arr.get(numofelements); arr.set(numofelements, null); return res; //class StackAsArray 8 4

5 בדומה למחסנית, אחד ממבני הנתונים השמישים בעולם התוכנה. עובד על עקרון של :FIFO הראשון להגיע הוא הראשון שייצא. :ADT public interface Queue { public void enqueue(object o); public Object dequeue(); public boolean isempty(); הכנסת איבר לסוף התור הוצאת איבר מתחילת התור enqueue dequeue 9 נממש תור ע"י מערך עם מצביעים של תחילה וסוף נחזיק את נתוני התור במערך בשם.data נחזיק מצביע front על האיבר הראשון בתור ומצביע rear על המקום הפנוי הבא בסוף התור. rear יצביע על המקום אליו מצביע front אם התור ריק אז המשמעות היא ש- front מצבע על מקום פנוי, כלומר, אין איברים בתור. 10 5

6 נתבונן במצב נתון של התור n D C 1 0 B A Max_Size rear front לאחר הוצאת A מראש התור: n D C B Max_Size rear front 11 הכנסת איבר תעשה במקום הפנוי הבא: כלומר.rear = rear + 1 rescale יצביע אל מעבר לגבולות המערך, נבצע rear אם כלומר הגדלת גודל המערך הוצאת איבר תחזיר את התא עליו מצביע front ונקדם את :front front = front + 1 אם התור ריק כלומר האם,rear == front אם כן נזרוק.exception 12 6

7 מימוש זה בעייתי היות והוא מאוד בזבזני במקום בגלל פעולות ה rescale ייתכן ונבצע rescale למערך בגודל 100 כאשר אפקטיבית יש בו איברים בודדים!! פתרון אפשרי: נדאג שבכל הוצאה האיבר שנותר ראשון בתור יישב במקום ה-[ 0 ] בעייתי מבחינת זמן הריצה אם התור הרבה איברים נצטרך להזיז כל אחד מהם וזה יהיה מאוד לא יעיל! פתרון פרקטי: נממש תור מעגלי!! 13 על מנת להמשיך לנצל את האיברים הראשונים במערך, נחשוב על המערך בתור מבנה מעגלי. נשתמש במודולו data.length הצבעה על המקום ה- data.length בעצם תצביע על המקום ה- 0 כפי שרצינו. 14 7

8 2 front 1 B C 0 A n-1 3 rear :front מצביע על האיבר שבראש התור :rear מצביע על המקום הפנוי הבא )סוף התור( אם אין איברים בתור אז rear==front הכנסה: אם התור מלא, נבצע rescale נכניס את האיבר הבא למקום ה- rear rear=(rear+1)%data.length כיצד נדע אם התור מלא? מספר האיברים שווה לגודל המערך 15 מהו מספר האיברים בתור? ניתן לחישוב ע"י? rear-front פתרון: משתנה ספירה יעודי 16 8

9 public class CircularQueue implements Queue { private Object [] data; private static final int INIT_SIZE = 10; // The Queue should be rescaled when the size is equal to the array length private static final int RESCALE = 2; private int size; // points to the first item in the Queue. // if no such one exists (size == 0) private int front; // points to the next free cell in the queue. private int rear; public CircularQueue() { data = new Object[INIT_SIZE]; front = 0; rear = 0; size = 0; 17 public void enqueue(object obj) { if (size == data.length){ rescale(); data[rear] = obj; rear = (rear + 1) % data.length; size = size + 1; public Object dequeue() { if (isempty()){ throw new EmptyQueueException("Trying to dequeue from an empty Queue"); else { Object ans = data[front]; front = (front + 1) % data.length; size = size - 1; return ans; 18 9

10 private void rescale() { Object [] temp = new Object[data.length * RESCALE]; for(int i = 0 ; i < data.length ; i = i + 1){ temp[(front + i) % temp.length] = data[(front + i) % data.length]; rear = (front + size) % temp.length; data = temp; public boolean isempty() { return (size == 0); 19 public class QueueAsStack implements Queue{ private Stack stack; public QueueAsStack () { stack = new StackAsArray(); public boolean isempty() {// easy... return stack.isempty(); public void enqueue(object o) {// easy as well... stack.push(o); 20 10

11 public Object dequeue() { // hard work... if (stack.isempty()) throw new EmptyQueueException("Trying to dequeue from an empty Queue"); Stack auxstack = new StackAsArray(); while(!stack.isempty()) { auxstack.push(stack.pop()); Object ret = auxstack.pop(); while(!auxstack.isempty()){ stack.push(auxstack.pop()); return ret; //class QueueAsStack 21 כיצד ניתן לבנות בנאי מעתיק למבנה הנתונים Set שלמדנו? כיצד ניתן לבצע איחוד או חיתוך בין שני אובייקטים מטיפוס? Set ישנו צורך בפונקציונליות חשובה ברוב מבני הנתונים שלמדנו שעד כה התעלמנו ממנה: היכולת לעבור על כל האיברים

12 public interface Iterator{ public boolean hasnext(); public Object next(); public void remove(); public interface Iterable { public Iterator iterator(); 23 :Set נעדכן את הממשק של public interface Set extends Iterable{ public void add(object data); public void remove(object data); public boolean contains(object data); public int size(); 24 12

13 Set נוסיף את השיטה הדרושה במימוש של public class SetAsArray implements Set{ private Array arr; int size; public Iterator iterator(){ return new ArrayIterator(arr,size);... //class SetAsArray 25 public class ArrayIterator implements Iterator{ private Array arr; private int nextix, size; public ArrayIterator(Array arr, int size) { this.arr = arr; this.size = size; nextix = 0; public boolean hasnext() { return nextix < size; 26 13

14 public Object next() { if (!hasnext()){ throw new NoSuchElementException(); nextix = nextix+1; return arr.get(nextix-1); public void remove() { throw new UnsupportedOperationException(); //class ArrayIterator 27 public class SetAsArray implements Set{ private Array arr; int size; public SetAsArray(){ arr = new DynamicArray(); size = 0; public SetAsArray(Set tocopy){ this(); if (tocopy == null) throw new NullPointerException("arguemnt to constructor is null"); Iterator iter = tocopy.iterator(); while (iter.hasnext()){ add(iter.next());... //class SetAsArray 28 14

15 public static void main(string[] args) { Set s1; Set s2; Iterator setiter; s1 = new SetAsArray(); s1.add("nothing"); s1.add("special"); s1.add("is"); s1.add("is"); s1.add("done"); s1.add("here!!"); s2 = new SetAsArray(s1); setiter = s2.iterator(); while (setiter.hasnext()){ System.out.print(setIter.next()+" "); >> Nothing special is done here!! 29 :Java חסרונות במערכים של מוגבלים במקום )סטטיים( גודל המערך נקבע עם הווצרו. הוספת איבר לאמצע המערך או לתחילתו בעייתית במקרה של הכנסה כזו, נאלצנו להזיז את כל האיברים שמימין לאיבר המוכנס את בעיית סטטיות פתרנו ע"י הגדרת מערך דינמי: בעיות זמן ריצה או מקום לפי מימוש ספציפי נידרש למבנה נתונים נוסף

16 רשימה מקושרת היא מבנה נתונים דינמי הבנוי מחוליות המחוברות זו לזו. לכל חולייה יש את המידע (data) שלה אותו היא שומרת )ממש כשם שלכל תא במערך יש ערך( בנוסף, לכל חולייה יש מצביע לאיבר הבא ברשימה Data Data Data Data 31 יתרונות )ביחס לבעיות שראינו במערכים( ניתן להוסיף חוליות חדשות כמות הזיכרון הנדרשת היא ביחס ישיר למספר החוליות )איברים( ברשימה. ההצבעה אל החוליה הבאה אינה קשיחה ניתן להכניס חוליה חדשה בין שתי חוליות קיימות הסרה של חוליה מתבצעת בקלות ניתן להסיר חוליה על ידי עדכון הקשר בין החוליה הקודמת לבאה

17 Data Data Data Data Data 33 Data Data Data Data Data 34 17

18 חסרון של רשימה מקושרת לעומת מערך אין גישה ישירה לאברים של מבנה הנתונים חיפוש איבר ברשימה, גם אם היא ממויינת ידרוש מעבר לינארי על )כמעט( כל אברי הרשימה. 35 public class Link { private Object data; private Link next; public Link(Object data, Link next) { this.data = data; this.next = next; public Link(Object data) { this(data, null); 36 18

19 // getters setters public Object getdata(){return data; public void setdata(object obj){data = obj; public Link getnext() {return next; public void setnext(link next){this.next = next; //Class Link 37?Link איזה שיטות נרצה שתהיינה למחלקה נרצה להוסיף חוליה חדשה בין ה- Link הנוכחי לבין ה- next שלו )הבא אחריו(: public void addnext(object toadd) נרצה להסיר את החוליה שמהווה הבאה של ה Link הנוכחי )ולגרום ל Link הנוכחי להצביע למי שכרגע הוא שני מקומות לפניו(: public Object removenext() 38 19

20 public void addnext(object toadd) { // Prepare a new link and make it point to the // next of this Link toaddlink = new Link(toAdd, next); next = toaddlink; 39 public Object removenext() { if (next == null){ throw new NullPointerException("No object to remove"); Object ans = next.getdata(); next = next.getnext(); return ans; 40 20

21 public String tostring() { String ans = ""; if (data!= null) { ans = data.tostring(); return ans; 41 :Link נראה דוגמא לקוד שמשתמש במחלקה public static void main(string[] args) { Link starter = new Link("I think"); Link middle = new Link("I have"); Link end = new Link("a DeJaVu!"); int j = 0; starter.setnext(middle); middle.setnext(end); end.setnext(starter); for(link tmp = starter; tmp!= null & j < 100; tmp=tmp.getnext(), j++) System.out.print(tmp + " "); 42 21

22 :Link פלט הקוד שהשתמש במחלקה I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think I have a DeJaVu! I think 43 מימוש המחלקה Link מאפשר "שימוש שגוי" למשל יצירת רשימה מעגלית LinkedList במחלקה Link נרצה לעטוף את המחלקה מאפשרת את היתרונות שקיבלנו מהמחלקה Link מונעת שימוש שגוי

23 public class LinkedList { private Link first; public LinkedList() { first = null; public boolean isempty() { return (first == null); 45 מחזירה את המידע של האיבר הראשון ברשימה public Object head(){ Object ans; if (isempty()){ ans = null; else { ans = first.getdata(); return ans; 46 23

24 להוספת איבר בהתחלה: נשתמש בבונה של Link ונגרום ל next של האיבר החדש להצביע על ראש הרשימה הנוכחית. ראש הרשימה החדש יהיה ה Link שיצרנו. public void addfirst(object obj) { Link newlink = new Link(obj, first); first = newlink; 47 מורידה את האיבר הראשון ברשימה ומחזירה את המידע שלו כערך מוחזר. public Object removefirst() { Object res = first.getdata(); if (isempty()){ throw new NullPointerException("No object to remove"); first = first.getnext(); return res; 48 24

25 בודקת האם איבר נתון נמצא ברשימה public boolean ismember(object obj) { boolean ans = false; Link tmp=first; while(!ans && tmp!=null){ if (tmp.getdata().equals(obj)){ ans = true; tmp=tmp.getnext(); // while return ans; 49 public String tostring() { String ans = "List: "; if (isempty()){ return ans + "Empty List"; Link tmp = first; while(tmp!= null){ ans = ans + tmp.tostring()+ ", "; tmp = tmp.getnext(); return ans; 50 25

26 obj מוחקת מהרשימה את כל המופעים של אובייקט נתון public void removeall(object obj) { boolean isfinished=false; if (!isempty()){ while(first.getdata().equals(obj)&&!isfinished) { removefirst(); if (isempty()) isfinished=true; // while if (!isfinished){ Link tmp = first; while(tmp.getnext()!= null) { if(tmp.getnext().getdata().equals(obj)) tmp.removenext(); else tmp = tmp.getnext(); // while //if //if //removeall 51 public void reverse() { LinkedList tmp = new LinkedList(); for(link i=first; i!=null; i=i.getnext()) { tmp.addfirst(i.getdata()); first = tmp.first; 52 26